Class={};
Class.classList={}; --保存所有已经定义过的类

--类的类型: 类和接口, 接口也是一种类
Class.TYPE_CLASS="Class";
Class.TYPE_INTERFACE="Interface";

function Class.isExist(className)
    return Class.classList[className] ~= nil;
end

--将定义的类注册,防止重复定义
function Class.register(className,clazz)
    if(Class.isExist(className)) then return end;
    Class.classList[className]=clazz;
end
function Class.getDefinedClass(className)
    return Class.classList[className];
end

-- 将错误信息返回而不是直接error, 这样在外层再通过error的level2 抛出异常,就能更精确定位到调用者
function Class._checkValid(class, clsType)
    clsType = clsType or Class.TYPE_CLASS;
    if(class==nil) then
        return clsType .. " 未定义!!";
    end
    if(type(class)~="table") then
        return "\""..tostring(class).."\" 不是一个" .. clsType .."!!";
    end
    local b = false;
    for k, v in pairs(Class.classList) do
        if(v == class) then
            b = true;
        end
    end
    if(not b) then
        return clsType .. " ".. tostring(class) .. " 未定义!!";
    end

    if (clsType==Class.TYPE_CLASS and class.__classType~=Class.TYPE_CLASS) or (clsType==Class.TYPE_INTERFACE and class.__classType~=Class.TYPE_INTERFACE) then
        return "\"" .. class.className .. "\" 不是一个 "..clsType.."!!";
    end

    return nil;
end

--定义一个类. 由于无法区分是没有传入extendsCls还是传入了一个错误的extendsCls,所以提供了define2来自动继承自Object. 这个方法是强制传入Object方法
--@param className 类名.字符串.
--@param ... 第一个参数是 extends 父类,后面要实现的一组接口.
function Class.define(className, ...)
    if(type(className)~="string") then
        return Class.TYPE_CLASS.." 名称 \""..tostring(className).."\" 无效!!";
    end
    if(Class.isExist(className)) then
        return Class.TYPE_CLASS.." \""..tostring(className).."\" 重复定义!!";
    end
    local cls = Class._define(Class.TYPE_CLASS, className, ...)
    if (type(cls)=="string") then
        error(cls, 2);
    end
    return cls;
end

---替换覆盖类定义
function Class.replace(className, ...)
    if(type(className)~="string") then
        return Class.TYPE_CLASS.." 名称 \""..tostring(className).."\" 无效!!";
    end
    local cls = Class._define(Class.TYPE_CLASS, className, ...)
    if (type(cls)=="string") then
        error(cls, 2);
    end
    return cls;
end

--lua 类对象扩展函数 用于将lua 拆分处理
function Class.extend(className)
    if not Class.isExist(className) then 
        error("className 还未定义 不能进行类扩展", 2);
    end;
    return Class.classList[className]
end

function Class._define(clsType, className, ...)
    local clazz={className=className, __classType=Class.TYPE_CLASS};
    --保存本类需要实现的接口,且不能重复实现同一接口
    local extendsCls;
    local arglen = select("#", ...);
    local err = nil;

    -- 说明没有显示传入继承的类
    if(arglen<1) then
        if(className=="Object") then
            extendsCls = nil;
        else
            extendsCls = Object;
        end
    else
        extendsCls = select(1,...);

        err = Class._checkValid(extendsCls,clsType);

        if(err) then
            return err;
        end
    end

    clazz.parentClass=extendsCls;

    clazz.__implements={};
    local _impl;
    for i=2, arglen do
        _impl = select(i, ...);
        --验证接口有效性
        err = Class._checkValid(_impl, Class.TYPE_INTERFACE);
        if(err) then
            return err;
        end

        --检查接口是否重复继承
        for _,v in ipairs(clazz.__implements) do
            if(v==_impl) then
                return Class.TYPE_INTERFACE.." \"".._impl.className.."\" 重复继承!!";
            end
        end

        table.insert(clazz.__implements, _impl);
    end

    if(className=="Object") then
        Class.register(className,clazz);
        return clazz;
    end

    Class.register(className,clazz);

    return clazz;
end

--检测当前类以及父类是否实现了相关接口的方法
function Class._checkImplements(cls, interfaces)
    if(#interfaces<1) then return end;

    local pInterface;
    for k,v in ipairs(interfaces) do
        --查找当前接口的所有方法是否被实现
        Class.__checkImplements(cls, v);

        --查找当前接口的父级接口的所有方法是否被实现
        pInterface=v.parentClass;
        while(pInterface) do
            Class.__checkImplements(cls, pInterface);
            pInterface=pInterface.parentClass;
        end
    end
end
--检测当前类和父类是否实现了一个接口的所有方法
function Class.__checkImplements(cls, interface)
    local b=true;
    local pcls;
    for name, func in pairs(interface) do
        if(type(func)=="function") then
            if(cls[name] and type(cls[name]=="function")) then return end

            --当本类中不存在这个,则在父类中查找
            pcls=cls.parentClass;
            while(pcls) do
                if(pcls[name] and type(pcls[name]=="function")) then return end
                pcls=pcls.parentClass;
            end

            --子类和父类中都没找到,说明没有实现
            error("\""..cls.className.."\" 未覆盖 \""..interface.className.."\" 中的抽象方法 "..name.."()");
        end
    end
end

function Class.createObjectFromClass(class)
    local o={};
    o.class=class;
    setmetatable(o,class);

    --设置访问时的操作
    class.__index=function(t,k) --属性和方法从本类开始往父类逐级找

        local v = nil;
        local pcls = t.class;
        while(pcls) do
            v = rawget(t.class, k);
            if(v) then return v end;

            pcls = pcls.parentClass;
        end

        return nil;
    end

    return o;
end

--验证构造参数合法性
function Class.checkCtor(class, ...)
    if(class==Object or class.parentClass==nil) then
        return;
    end

    --产生一个无参构造.
    if(class._ctor == nil and class.ctor == nil) then
        class._ctor = function() end;
    end

    Class.checkCtor(class.parentClass);
end

--new一个对象的实例
function Class.new(class, ...)
    Class._checkValid(class);

    --检查接口的实现情况
    Class._checkImplements(class, class.__implements);

    --如果都没显示指定无参构造函数,则在checkCtor()中生成一个无参的构造函数
    Class.checkCtor(class, ...);

    -- 获取参数的真实长度, 用来区分传入的参数在为nil时,到底是调用者填写的nil还是系统默认的nil
    local arglen = select("#", ...);
    --如果当前类没有有参构造,则参数必须为空
    if(class.ctor == nil and arglen ~= 0) then
        error("构造函数错误,不存在有参构造函数. Class "..class.className);
    elseif(class._ctor == nil and arglen == 0) then
        error("构造函数错误,不存在无参构造函数. Class "..class.className);
    end

    -- 将父类的所有定义的属性拿出来放到一个映射表中
    local attributes = {}; -- Map<类名, Map<属名,value> >

    -- 将类链表中定义的方法做个列表存放起来. 每个类自己定义的方法都做单独保存,主要为super提供
    local functionsMap = {}; -- Map<类名, Map<方法名,func> >
    --保存最后实现的那些方法. 实现多态.
    functionsMap.lastFuncs = {};

    --查找类链
    local _clsListTemp = {};
    local pcls=class;
    while(pcls~=nil) do
        table.insert(_clsListTemp, pcls);
        pcls = pcls.parentClass;
    end

    --先从上往下依次调用类链中的所有方法.
    local _cls = nil;
    for i = #_clsListTemp, 1, -1 do
        _cls = _clsListTemp[i];

        functionsMap[_cls] = {};

        --找出方法,保存到方法列表中
        for k,v in pairs(_cls) do
            --本来应该检查方法名称是否和属性名称重复. java中可以做到方法名和属性名重复, 但lua不行,会覆盖.

            --默认的无参构造函数不存起来,因为会自动都调用一次.
            if(type(v)=="function" and k~="_ctor" and k~="__index" and k~="__newindex") then
                if(k=="getter_ctor" or k=="setter_ctor" or k=="getter__ctor" or k=="setter__ctor") then
                    error("不能将构造方法定义为getter或setter方法!!");
                end

                --保存对应的方法列表. 默认指向最后的实现者,但也保存每个类中自己的那个方法,以便通过super调用的时候找到对应的方法.
                functionsMap[_cls][k] = v;

                --由于是从上往下调用,所以子类覆盖的方法会被正确指向. 有参构造不能覆盖保存.
                if(k~="ctor") then
                    functionsMap.lastFuncs[k] = v;
                end
            end
        end
    end

    local obj = {};
    -- obj 是在new之后返回的一个空的代理对象, 真正的对象是这个meta,所有表象上看起来的属性的访问和修改也来自于这个meta.
    -- 这样也方便的模拟实现了 getter 和 setter
    local meta = {class = class, __attributes = attributes, __functionsMap = functionsMap};

    setmetatable(obj, meta);
    --设置键为弱引用.
    meta.__mode="k";

    --访问属性和方法
    meta.__index = function(t, k)
        if(k=="_ctor") then return nil end

        local m = getmetatable(t);
        if(k=="class") then return m.class end

        local attr,func;

        --先从属性查找
        attr = m.__attributes[k];

        if(attr~=nil) then return attr end

        -- 判断是否有getter方法,如果有getter方法,优先调用getter方法
        func = m.__functionsMap.lastFuncs["getter_"..k];
        if(func~=nil) then
            return func(t);
        end

        --方法.
        func = m.__functionsMap.lastFuncs[k];
        if(func ~= nil) then return func end

        --如果元表对象中找不到,则从类链中查找. 在java中的表现为用实例化对象去访问它的类的静态属性或方法.
        local pcls = m.class;
        while(pcls~=nil) do
            attr = pcls[k];
            if(attr~=nil) then
                --如果是方法, 进行一次代理访问方法, 不会把这个方法返回出去.
                --因为外部可能是冒号访问, 而类的静态方法只能是点号访问, 这样在那些方法内部使用self会出错. 变相的做了限制
                if(type(attr) == "function") then
                    return attr();
                end
                return attr;
            end

            pcls = pcls.parentClass;
        end
        return nil;
    end

    --修改属性和方法
    meta.__newindex = function(t, k, v)
        if(k=="class") then
            error("class 是只读属性. \""..m.class.classNa.."\" !!");
        end

        if(k=="ctor" or k=="_ctor") then
            error("不能将构造方法定义为属性!!");
        end

        local m = getmetatable(t);

        if(m.__functionsMap.lastFuncs[k] and v~=nil) then
            --判断这个方法是否是一个getter,setter方法. 如果是,则不能允许属性存在重复定义
            local stind,endind = string.find(k,"getter_");
            local subname = nil;
            if(stind~=nil) then
                subname = string.sub(k,endind+1);
            else
                stind,endind = string.find(k,"setter_");
                if(stind~=nil) then
                    subname = string.sub(k,endind+1);
                end
            end

            if(subname) then
                error("不能重新定义Class \"".. m.class.className .."\" 的getter, setter方法 \""..subname.."\" !!");
            --else
            --    error("不能重新定义Class \"".. m.class.className .."\" 的方法 \""..k.."\" !!");
            end
        end

        --改变的值不是一个方法. 就添加到属性列表中
        if(type(v)~="function") then

            -- 判断是否有setter方法,如果有setter方法,优先调用setter方法
            local func = m.__functionsMap.lastFuncs["setter_"..k];
            if(func~=nil) then
                return func(t, v);
            end

            m.__attributes[k] = v;
            return;
        else
            -- error("不能为Class \"".. m.class.className .."\" 的实例动态添加方法 \""..k.."\" !!");
            m.__functionsMap.lastFuncs[k] = v;
        end
    end

    --由于上面已经找出了所有方法, 所以在构造函数中就可以访问那些方法了. 也就是在构造函数中执行一些逻辑.
    for i = #_clsListTemp, 1, -1 do
        _cls = _clsListTemp[i];

        --产生_cls的临时对象
        local __o = Class.createObjectFromClass(_cls);

        --这里用点号访问,并传入了代理的obj对象,这样在_ctor定义的属性就会保存到obj元表对象meta的 attributes中(通过上面的__newindex操作).
        --如果在_ctor中初始调用逻辑方法,也能在obj元表meta的functionsMap 中正确访问到.
        --如果出现重复定义属性, 这里没有使用像java一样的方式保存在不同类中定义的相同属性的副本.
        --有点像actionscript中一样不能重复定义(as中父类的属性可见性要比子类小,否则就报重复定义的编译级错误).
        --但这里没有实现 private 这样的可见性, 所以全部视为 public. 那自然不允许重复定义属性.
        --理论上应该做一次检查,如果重复定义要报错.但lua没有像其它预编译语言的定义属性的概念,
        --并且我无法知道子类在构造方法内部写self.xx=value 时到底是定义这个属性还是更改它的值(如果它已经在父类中定义了)
        --所以这里统一处理,不存在就定义,存在就覆盖.
        --并且由于ctor 不能被覆盖,在上面存储方法时已经屏蔽了ctor方法,但_ctor方法中可能会调用ctor方法,且此时只能访问自己这个类中的ctor方法,
        --那就要将这个存在的ctor从__o中取出来放到obj的元表中临时保存起来,再调用_ctor时,如果内部又要调用ctor才不会出错,且能正确调用到类链中对应位置的ctor.
        if(__o.ctor~=nil) then
            getmetatable(obj).__functionsMap.lastFuncs.ctor=__o.ctor;
        end

        --自动调用了一次每个类的无参构造函数.
        --这里和java不一样, java是当new时不传参数时,才会调用无参构造,且如果这个无参构造里没有显示写super,又会自动调用父类的无参构造.
        --但在这里我无法知道到底有没有在代码内部显示写super, 就不知道是否该自动调用父类的无参构造.
        --如果不自动统一调用,那每个子类都要显示写上无参构造函数并在内部写self:super(class,"_ctor").
        --为了业务统一方便,这里自动调用, 所以在无参构造函数里尽量不要包含对其它函数的调用,免得逻辑重复.
        if(__o._ctor~=nil) then
            __o._ctor(obj);
        end

        --如果子类没有定义他自己的ctor,但子类的_ctor中又写self:ctor()这样的语句,就可能会调用到父类的ctor方法.这是错误的.
        --所以不管_ctor内部是否调用过了ctor,之后都要将临时保存的ctor清除。
        if(__o.ctor~=nil) then
            getmetatable(obj).__functionsMap.lastFuncs.ctor=nil;
        end
    end

    --如果存在参数就调用本类的有参的构造ctor(). 父类的有参构造不会被自动调用,只有子类显示写self:super(class, k, ...);
    local arglen = select("#", ...); -- 只有调用者真正的写了参数,即使是nil,才能调用有参构造
    local ctorFunc = arglen~=0 and getmetatable(obj).__functionsMap[class].ctor;
    if(ctorFunc) then
        ctorFunc(obj, ...);
    end

    return obj;
end

--假如这个super是一个简单实现,没有第一个class作为参数,出现的情况是:
--设有类 A <- B <- C <- D 其中在A类中定义了func1, 在C类中覆盖了func1,并在方法代码内部简单写super(self,"walk").
--现在Class.new(D),并通过D的实例调用func1. 正确的逻辑应该是访问到C 的func1,然后又访问到A 的func1.
--但方法都是冒号访问, 所以用C 类中的func1里的super(self,"walk")这个self的引用实际上是D 的实例. 如果不进行判断,就会陷入死循环.
--这里传入cls就是明确告诉我当前覆盖walk方法的类是哪个, 再从cls的父类继续找到A.
--如果不传入cls, 那我无法知道当前super代码位于哪个类里面, 就可能导致陷入循环(B和C的walk方法里都写生super时就会陷入死循环)
--所以第一个参数class只能通过外部显示传入.
function super(cls, t, k, ...)
    Class._checkValid(cls);

    if(instanceof(t,Object)==false) then
        error("参数类型错误. 不是一个正确的Object实例!!");
    end

    Class._checkValid(t.class);

    if(type(k)~="string") then
        error("参数类型错误. 使用 super 访问时,只能传入属性或方法的字符串名称!!");
    end
    local m = getmetatable(t);

    local pcls = cls.parentClass;
    local func = nil;
    if(pcls==nil) then
        error("访问 Class \""..cls.className.."\" 的父类不存在!!");
    end
    if(k=="ctor") then
        func = m.__functionsMap[pcls][k];
        if(func~=nil) then
            return func(t, ...);
        else
            error("访问 Class \""..t.class.className.."\" super的方法 \""..k.."\" 不存在!!");
        end
    end

    --属性. 这里没有像java一样也保存了父类的相同名称的属性的副本. 即用super时也会得到这个属性最后被改过的那个值
    local attr = m.__attributes[k];
    if(attr~=nil) then
        return attr;
    end

    --检查t的class中是否有k方法
    while(pcls~=nil)do
        func = m.__functionsMap[pcls][k];
        if(func~=nil) then
            return func(t, ...);
        end

        pcls = pcls.parentClass;
    end

    error("访问 Class \""..t.class.className.."\" super的方法 \""..k.."\" 不存在!!");
end


local _instanceof;
-- 一个对象是否是一个类或接口的实例
function instanceof(obj,class)
    if(obj==nil or type(obj)~="table" or obj.class==nil) then
        -- print("参数错误 1, 不是一个对象!!");
        return false;
    end

    Class._checkValid(class);

    if(rawget(class,"__classType")==nil) then
        error("参数错误 2,不是一个类!!");
    end
    if(class==Object) then return true end

    local ocls=obj.class;
    if(ocls==class) then return true end
    local pcls,b=nil,false;
    --如果是个类,则查找父类
    if(class.__classType == Class.TYPE_CLASS) then
        pcls=ocls.parentClass;
        while(pcls~=nil) do
            if(pcls==class) then return true end
            pcls=pcls.parentClass;
        end
    --如果是个接口,则在本类和父类的所有接口中查找
    elseif(class.__classType == Class.TYPE_INTERFACE) then

        b=_instanceof(ocls,class);
        if(b) then return true end
        pcls=ocls.parentClass;

        while(pcls~=nil) do
            b=_instanceof(pcls,class);
            if(b) then return true end
            pcls=pcls.parentClass;
        end
    end

    return false;
end

_instanceof=function(cls,class)
    local interfaces,pInterface,b=cls.__implements,nil,false;
    if(#interfaces<1) then return false end

    --可能会重复查找相关接口
    for k,v in ipairs(interfaces) do
        if(class==v) then return true end

        --查找当前接口的父级接口的所有方法是否被实现
        pInterface=v.parentClass;
        while(pInterface~=nil) do
            if(class==pInterface) then return true end
            pInterface=pInterface.parentClass;
        end
    end

    return false;
end

-----------------------------------------
--Object
Object=Class.define("Object");
function Object:_ctor()
    --print("Object _ctor");
end

--提供一个便捷访问. 每个类的实例就可以通过 self:super(cls,k,...)来访问
function Object:super(cls, k, ...)
    super(cls, self, k, ...);
end


Class.define("Class"); --定义class本身

--接口
Interface=Class.define("Interface");
function Interface.define(interfaceName, ...)

    local arglen, cls,extendsInterface;
    arglen = select("#", ...);

    if(arglen<1) then

        cls = Class._define(Class.TYPE_INTERFACE, interfaceName);

    else
        if(arglen>1) then
            error(Class.TYPE_INTERFACE.." 只能继承一个接口!!", 2);
        end

        extendsInterface = select(1, ...);
        Class._checkValid(extendsInterface, Class.TYPE_INTERFACE);

        cls = Class._define(Class.TYPE_INTERFACE, interfaceName, extendsInterface);
    end

    if (type(cls)=="string") then
        error(cls, 2);
    end

    cls.__classType=Class.TYPE_INTERFACE;
    return cls;
end







-- IPerson = Interface.define("IPerson");
-- function IPerson.walk() end
-- function IPerson.talk() end

-- Role = Class.define("Role", Object, IPerson);
-- function Role:walk()
--     print("walk");
-- end
-- function Role:talk()
--     print("talk");
-- end

-- Monster = Class.define("Monster", Role);
-- Class.new(Monster):walk();

-- People = Class.define("People", Role);
-- local p = Class.new(People);
-- p:walk();
-- p:talk();


--=============== 模拟测试 =================
--[[测试继承和接口

IPerson = Interface.define("IPerson");
function IPerson.walk() end

Role = Class.define("Role", Object, IPerson);
function Role:walk()
    print("walk");
end

Monster = Class.define("Monster", Role);
Class.new(Monster):walk();
-- ]]
--[[测试构造函数
Role = Class.define("Role");
function Role:_ctor()
    self:ctor("defName");
end
function Role:ctor(name)
    self.name=name;
    self:walk();
end
function Role:walk()
    print(self.name .." walk");
end

Monster = Class.define("Monster", Role);

--这里monster没有定义任何构造函数,会自动产生一个无参构造函数. 详见Class.checkCtor()方法.
Class.new(Monster);
--]]
--[[测试构造函数2 (这是一个注意的地方)
Role = Class.define("Role");
function Role:_ctor()
    self:ctor("defName");
end
function Role:ctor(name)
    self.name=name;
    self:walk();
end
function Role:walk()
    print(self.name .." walk");
end

Monster = Class.define("Monster", Role);
function Monster:ctor(name)
    self:super(Monster,"ctor",name);
end

Class.new(Monster,"m1");

-- 这里打印的结果是:
-- defName walk
-- m1 walk
-- 这是一个相对于java来说错误的结果. 在java里,只会打印出m1 walk. 因为这里我默认自动调用了类链中的每个无参构造
--]]
--[[测试方法的重写与super
Role = Class.define("Role");
function Role:ctor(name)
    self.name=name;
end
function Role:walk()
    print(self.name .." role walk");
    self:speak();
end
function Role:speak()
    print("role speak");
end

Monster = Class.define("Monster", Role);
function Monster:ctor(name)
    self:super(Monster,"ctor",name);
end
function Monster:walk()
    print("monster walk");
    self:super(Monster,"walk");
end
function Monster:speak()
    print("monster speak");
end

Class.new(Monster,"m1"):walk();

-- 结果如下:
-- monster walk
-- m1 role walk
-- monster sepak
-- 即,在父类中调用的speak()方法被正确的指向到了子类, 通过super也能正确的访问到父类的walk方法
--]]
--测试getter, setter(类似as3,c#,vb.net等语言中的 get,set 方法)
--[[这里我规定的是,以getter_,setter_开头的方法会作为getter和setter方法来解析
Role = Class.define("Role");
function Role:_ctor()
    self._name=nil;
end
function Role:setter_name(v)
    self._name=v;
end
function Role:getter_name()
    return self._name;
end

local r = Class.new(Role);
r.name="r1";
print(r.name);

-- 结果如下:
-- setter_name
-- getter_name
-- r1
-- 说明正确的访问到了getter和setter,为属性的访问提供了更多的逻辑操作
--]]
--[[更多的测试
Role = Class.define("Role");
Role.name="static name";
Role.age=10;
function Role:_ctor()
    print("role self: ",self);
    self.age=20;
end

Monster = Class.define("Monster", Role);
function Monster:_ctor()
    print("monster self: ",self);
end

local m = Class.new(Monster);
print(m.name, Role.name, m.age, Role.age);
结果如下:
role self: table: 00437678
monster self: table: 00437678
static name    static name    20    10
可以看到在Role中的self和Monster是一个对象.java中也是如此.详见358行
通过实例对象也能访问到Role的静态属性name,也打印出了正确的结果,这点和java一样.
但对于age却不一样, java中会报一个错误,因为重复定义了age, 这里为了节约性能,我没有做过多的重复定义的检查.所以看到的结果是self访问到实例中的age.所以这种情况只能自己避免去写.
--]]